﻿using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;

using BodaNetCommunications.Utilities.ComTypes;

namespace BodaNetCommunications.Utilities.DataLibs
{
    //
    // 摘要:
    //     字节数组转换库
    public class ByteArrayLib
    {
        private static List<char> hexCharList = new List<char>
    {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
        'A', 'B', 'C', 'D', 'E', 'F'
    };

        //
        // 摘要:
        //     自定义截取字节数组
        //
        // 参数:
        //   source:
        //     字节数组
        //
        //   start:
        //     开始字节
        //
        //   length:
        //     截取长度
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArray(byte[] source, int start, int length)
        {
            byte[] array = new byte[length];
            if (source != null && start >= 0 && length > 0 && source.Length >= start + length)
            {
                Array.Copy(source, start, array, 0, length);
                return array;
            }

            return null;
        }

        //
        // 摘要:
        //     从字节数组中截取2个字节
        //
        // 参数:
        //   source:
        //     字节数组
        //
        //   start:
        //     开始索引
        //
        //   type:
        //     字节顺序，默认为ABCD
        //
        // 返回结果:
        //     字节数组
        public static byte[] Get2ByteArray(byte[] source, int start, EndianType type = EndianType.ABCD)
        {
            byte[] array = new byte[2];
            byte[] byteArray = GetByteArray(source, start, 2);
            if (byteArray == null)
            {
                return null;
            }

            switch (type)
            {
                case EndianType.ABCD:
                case EndianType.CDAB:
                    array[0] = byteArray[1];
                    array[1] = byteArray[0];
                    break;

                case EndianType.BADC:
                case EndianType.DCBA:
                    array = byteArray;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     从字节数组中截取4个字节
        //
        // 参数:
        //   source:
        //     字节数组
        //
        //   start:
        //     开始索引
        //
        //   type:
        //     字节顺序，默认为ABCD
        //
        // 返回结果:
        //     字节数组
        public static byte[] Get4ByteArray(byte[] source, int start, EndianType type = EndianType.ABCD)
        {
            byte[] array = new byte[4];
            byte[] byteArray = GetByteArray(source, start, 4);
            if (byteArray == null)
            {
                return null;
            }

            switch (type)
            {
                case EndianType.ABCD:
                    array[0] = byteArray[3];
                    array[1] = byteArray[2];
                    array[2] = byteArray[1];
                    array[3] = byteArray[0];
                    break;

                case EndianType.CDAB:
                    array[0] = byteArray[1];
                    array[1] = byteArray[0];
                    array[2] = byteArray[3];
                    array[3] = byteArray[2];
                    break;

                case EndianType.BADC:
                    array[0] = byteArray[2];
                    array[1] = byteArray[3];
                    array[2] = byteArray[0];
                    array[3] = byteArray[1];
                    break;

                case EndianType.DCBA:
                    array = byteArray;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     从字节数组中截取8个字节
        //
        // 参数:
        //   source:
        //     字节数组
        //
        //   start:
        //     开始索引
        //
        //   type:
        //     字节顺序，默认为ABCD
        //
        // 返回结果:
        //     字节数组
        public static byte[] Get8ByteArray(byte[] source, int start, EndianType type = EndianType.ABCD)
        {
            byte[] array = new byte[8];
            byte[] byteArray = GetByteArray(source, start, 8);
            if (byteArray == null)
            {
                return null;
            }

            switch (type)
            {
                case EndianType.ABCD:
                    array[0] = byteArray[7];
                    array[1] = byteArray[6];
                    array[2] = byteArray[5];
                    array[3] = byteArray[4];
                    array[4] = byteArray[3];
                    array[5] = byteArray[2];
                    array[6] = byteArray[1];
                    array[7] = byteArray[0];
                    break;

                case EndianType.CDAB:
                    array[0] = byteArray[1];
                    array[1] = byteArray[0];
                    array[2] = byteArray[3];
                    array[3] = byteArray[2];
                    array[4] = byteArray[5];
                    array[5] = byteArray[4];
                    array[6] = byteArray[7];
                    array[7] = byteArray[6];
                    break;

                case EndianType.BADC:
                    array[0] = byteArray[6];
                    array[1] = byteArray[7];
                    array[2] = byteArray[4];
                    array[3] = byteArray[5];
                    array[4] = byteArray[2];
                    array[5] = byteArray[3];
                    array[6] = byteArray[0];
                    array[7] = byteArray[1];
                    break;

                case EndianType.DCBA:
                    array = byteArray;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     比较两个字节数组是否完全相同
        //
        // 参数:
        //   b1:
        //     字节数组1
        //
        //   b2:
        //     字节数组2
        //
        // 返回结果:
        //     是否相同
        public static bool ByteArrayEquals(byte[] b1, byte[] b2)
        {
            if (b1 == null || b2 == null)
            {
                return false;
            }

            if (b1.Length != b2.Length)
            {
                return false;
            }

            for (int i = 0; i < b1.Length; i++)
            {
                if (b1[i] != b2[i])
                {
                    return false;
                }
            }

            return true;
        }

        //
        // 摘要:
        //     将单个字节转换成字节数组
        //
        // 参数:
        //   value:
        //     单个字节
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromByte(byte value)
        {
            return new byte[1] { value };
        }

        //
        // 摘要:
        //     将Short类型数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Short类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromShort(short SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[2];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    break;

                case EndianType.BADC:
                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将UShort类型数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     UShort类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromUShort(ushort SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[2];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    break;

                case EndianType.BADC:
                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将Short数组转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Short数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromShortArray(short[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (short setValue in SetValue)
            {
                byteArray.Add(GetByteArrayFromShort(setValue, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将UShort数组转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     UShort数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromUShortArray(ushort[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (ushort setValue in SetValue)
            {
                byteArray.Add(GetByteArrayFromUShort(setValue, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将Int类型数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Int类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromInt(int SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[4];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                    array[0] = bytes[3];
                    array[1] = bytes[2];
                    array[2] = bytes[1];
                    array[3] = bytes[0];
                    break;

                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    array[2] = bytes[3];
                    array[3] = bytes[2];
                    break;

                case EndianType.BADC:
                    array[0] = bytes[2];
                    array[1] = bytes[3];
                    array[2] = bytes[0];
                    array[3] = bytes[1];
                    break;

                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将UInt类型数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     UInt类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromUInt(uint SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[4];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                    array[0] = bytes[3];
                    array[1] = bytes[2];
                    array[2] = bytes[1];
                    array[3] = bytes[0];
                    break;

                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    array[2] = bytes[3];
                    array[3] = bytes[2];
                    break;

                case EndianType.BADC:
                    array[0] = bytes[2];
                    array[1] = bytes[3];
                    array[2] = bytes[0];
                    array[3] = bytes[1];
                    break;

                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将Float数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Float类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromFloat(float SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[4];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                    array[0] = bytes[3];
                    array[1] = bytes[2];
                    array[2] = bytes[1];
                    array[3] = bytes[0];
                    break;

                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    array[2] = bytes[3];
                    array[3] = bytes[2];
                    break;

                case EndianType.BADC:
                    array[0] = bytes[2];
                    array[1] = bytes[3];
                    array[2] = bytes[0];
                    array[3] = bytes[1];
                    break;

                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将Double类型数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Double类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromDouble(double SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[8];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                    array[0] = bytes[7];
                    array[1] = bytes[6];
                    array[2] = bytes[5];
                    array[3] = bytes[4];
                    array[4] = bytes[3];
                    array[5] = bytes[2];
                    array[6] = bytes[1];
                    array[7] = bytes[0];
                    break;

                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    array[2] = bytes[3];
                    array[3] = bytes[2];
                    array[4] = bytes[5];
                    array[5] = bytes[4];
                    array[6] = bytes[7];
                    array[7] = bytes[6];
                    break;

                case EndianType.BADC:
                    array[0] = bytes[6];
                    array[1] = bytes[7];
                    array[2] = bytes[4];
                    array[3] = bytes[5];
                    array[4] = bytes[2];
                    array[5] = bytes[3];
                    array[6] = bytes[0];
                    array[7] = bytes[1];
                    break;

                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将Int类型数组转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Int类型数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromIntArray(int[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (int setValue in SetValue)
            {
                byteArray.Add(GetByteArrayFromInt(setValue, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将UInt类型数组转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     UInt类型数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromUIntArray(uint[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (uint setValue in SetValue)
            {
                byteArray.Add(GetByteArrayFromUInt(setValue, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将Float类型数组转成字节数组
        //
        // 参数:
        //   SetValue:
        //     Float类型数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromFloatArray(float[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (float setValue in SetValue)
            {
                byteArray.Add(GetByteArrayFromFloat(setValue, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将Double类型数组转成字节数组
        //
        // 参数:
        //   SetValue:
        //     Double类型数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromDoubleArray(double[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (double setValue in SetValue)
            {
                byteArray.Add(GetByteArrayFromDouble(setValue, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将Long类型数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Long类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromLong(long SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[8];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                    array[0] = bytes[7];
                    array[1] = bytes[6];
                    array[2] = bytes[5];
                    array[3] = bytes[4];
                    array[4] = bytes[3];
                    array[5] = bytes[2];
                    array[6] = bytes[1];
                    array[7] = bytes[0];
                    break;

                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    array[2] = bytes[3];
                    array[3] = bytes[2];
                    array[4] = bytes[5];
                    array[5] = bytes[4];
                    array[6] = bytes[7];
                    array[7] = bytes[6];
                    break;

                case EndianType.BADC:
                    array[0] = bytes[6];
                    array[1] = bytes[7];
                    array[2] = bytes[4];
                    array[3] = bytes[5];
                    array[4] = bytes[2];
                    array[5] = bytes[3];
                    array[6] = bytes[0];
                    array[7] = bytes[1];
                    break;

                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将ULong类型数值转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     ULong类型数值
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromULong(ulong SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            byte[] bytes = BitConverter.GetBytes(SetValue);
            byte[] array = new byte[8];
            switch (dataFormat)
            {
                case EndianType.ABCD:
                    array[0] = bytes[7];
                    array[1] = bytes[6];
                    array[2] = bytes[5];
                    array[3] = bytes[4];
                    array[4] = bytes[3];
                    array[5] = bytes[2];
                    array[6] = bytes[1];
                    array[7] = bytes[0];
                    break;

                case EndianType.CDAB:
                    array[0] = bytes[1];
                    array[1] = bytes[0];
                    array[2] = bytes[3];
                    array[3] = bytes[2];
                    array[4] = bytes[5];
                    array[5] = bytes[4];
                    array[6] = bytes[7];
                    array[7] = bytes[6];
                    break;

                case EndianType.BADC:
                    array[0] = bytes[6];
                    array[1] = bytes[7];
                    array[2] = bytes[4];
                    array[3] = bytes[5];
                    array[4] = bytes[2];
                    array[5] = bytes[3];
                    array[6] = bytes[0];
                    array[7] = bytes[1];
                    break;

                case EndianType.DCBA:
                    array = bytes;
                    break;
            }

            return array;
        }

        //
        // 摘要:
        //     将Long类型数组转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     Long类型数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromLongArray(long[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (long num in SetValue)
            {
                byteArray.Add(GetByteArrayFromDouble(num, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将ULong类型数组转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     ULong类型数组
        //
        //   dataFormat:
        //     字节顺序
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromULongArray(ulong[] SetValue, EndianType dataFormat = EndianType.ABCD)
        {
            ByteArray byteArray = new ByteArray();
            foreach (ulong num in SetValue)
            {
                byteArray.Add(GetByteArrayFromDouble(num, dataFormat));
            }

            return byteArray.array;
        }

        //
        // 摘要:
        //     将指定编码格式的字符串转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     字符串
        //
        //   encoding:
        //     编码格式
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromString(string SetValue, Encoding encoding)
        {
            return encoding.GetBytes(SetValue);
        }

        //
        // 摘要:
        //     将16进制字符串按照空格分隔成字节数组
        //
        // 参数:
        //   val:
        //     16进制字符串
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromHexString(string val)
        {
            List<byte> list = new List<byte>();
            if (val.Contains(' '))
            {
                string[] array = Regex.Split(val, "\\s+", RegexOptions.IgnoreCase);
                string[] array2 = array;
                foreach (string value in array2)
                {
                    list.Add(Convert.ToByte(value));
                }
            }
            else
            {
                list.Add(Convert.ToByte(val));
            }

            return list.ToArray();
        }

        //
        // 摘要:
        //     将16进制字符串不用分隔符转换成字节数组（每2个字符为1个字节）
        //
        // 参数:
        //   val:
        //     16进制字符串
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromHexStringWithoutSpilt(string val)
        {
            val = val.ToUpper();
            MemoryStream memoryStream = new MemoryStream();
            for (int i = 0; i < val.Length; i++)
            {
                if (i + 1 < val.Length && hexCharList.Contains(val[i]) && hexCharList.Contains(val[i + 1]))
                {
                    memoryStream.WriteByte((byte)(hexCharList.IndexOf(val[i]) * 16 + hexCharList.IndexOf(val[i + 1])));
                    i++;
                }
            }

            byte[] result = memoryStream.ToArray();
            memoryStream.Dispose();
            return result;
        }

        //
        // 摘要:
        //     将布尔数组转换成字节数组
        //
        // 参数:
        //   val:
        //     布尔数组
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromBoolArray(bool[] val)
        {
            if (val == null && val.Length == 0)
            {
                return null;
            }

            int num = 0;
            num = val.Length % 8 != 0 ? val.Length / 8 + 1 : val.Length / 8;
            byte[] array = new byte[num];
            for (int i = 0; i < num; i++)
            {
                int num2 = val.Length < 8 * (i + 1) ? val.Length - 8 * i : 8;
                for (int j = 0; j < num2; j++)
                {
                    array[i] = ByteLib.SetbitValue(array[i], j, val[8 * i + j]);
                }
            }

            return array;
        }

        //
        // 摘要:
        //     将西门子字符串转换成字节数组
        //
        // 参数:
        //   SetValue:
        //     西门子字符串
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetByteArrayFromSiemensString(string SetValue)
        {
            byte[] byteArrayFromString = GetByteArrayFromString(SetValue, Encoding.GetEncoding("GBK"));
            byte[] array = new byte[byteArrayFromString.Length + 2];
            array[1] = (byte)byteArrayFromString.Length;
            Array.Copy(byteArrayFromString, 0, array, 2, byteArrayFromString.Length);
            return array;
        }

        //
        // 摘要:
        //     将字节数组转换成ASCII字节数组
        //
        // 参数:
        //   inBytes:
        //     字节数组
        //
        // 返回结果:
        //     ASCII字节数组
        public static byte[] GetAsciiBytesFromByteArray(byte[] inBytes)
        {
            return Encoding.ASCII.GetBytes(StringLib.GetHexStringFromByteArray(inBytes, '\0'));
        }

        //
        // 摘要:
        //     将2个字节数组进行合并
        //
        // 参数:
        //   bytes1:
        //     字节数组1
        //
        //   bytes2:
        //     字节数组2
        //
        // 返回结果:
        //     字节数组
        public static byte[] CombineTwoByteArray(byte[] bytes1, byte[] bytes2)
        {
            if (bytes1 == null && bytes2 == null)
            {
                return null;
            }

            if (bytes1 == null)
            {
                return bytes2;
            }

            if (bytes2 == null)
            {
                return bytes1;
            }

            byte[] array = new byte[bytes1.Length + bytes2.Length];
            bytes1.CopyTo(array, 0);
            bytes2.CopyTo(array, bytes1.Length);
            return array;
        }

        //
        // 摘要:
        //     将3个字节数组进行合并
        //
        // 参数:
        //   bytes1:
        //     字节数组1
        //
        //   bytes2:
        //     字节数组2
        //
        //   bytes3:
        //     字节数组3
        public static byte[] CombineThreeByteArray(byte[] bytes1, byte[] bytes2, byte[] bytes3)
        {
            return CombineTwoByteArray(CombineTwoByteArray(bytes1, bytes2), bytes3);
        }

        //
        // 摘要:
        //     将ASCII字节数组转换成字节数组
        //
        // 参数:
        //   inBytes:
        //     ASCII字节数组
        //
        // 返回结果:
        //     字节数组
        public static byte[] GetBytesArrayFromASCIIByteArray(byte[] inBytes)
        {
            return GetByteArrayFromHexStringWithoutSpilt(Encoding.ASCII.GetString(inBytes));
        }
    }
}